const express = require('express')
const router = express.Router()
const Chat = require('../models/chatModel')
const User = require('../models/userModel')
const checkTokenMiddleware = require('../middlewares/checkTokenMiddleware')
const FriendshipModel = require('../models/friendshipfModel')
// 导入mongoose
const mongoose = require('mongoose')
// 获取与好友的全部聊天记录
// 修改:将房间号返回
// router.post('/chatRecords',checkTokenMiddleware, async (req, res) => {
//     try {
//         // 获取请求体中的senderId和receiverId
//         const { senderId, receiverId, keyword } = req.body;

//         if (!senderId || !receiverId) {
//             return res.status(400).json({ message: "senderId and receiverId are required" });
//         }

//         // 构建查询条件
//         let query = {
//             $or: [
//                 { senderId, receiverId },  // 查询发送者为senderId，接收者为receiverId的记录
//                 { senderId: receiverId, receiverId: senderId }  // 查询发送者为receiverId，接收者为senderId的记录
//             ]
//         };
//         // 如果有额外的查询条件，更新查询条件
//         if (keyword) {
//             query.content = { $regex: keyword, $options: 'i' };  // 模糊搜索内容
//         }
//            // 查询聊天记录：使用构建的查询条件
//         const chatRecords = await Chat.find(query)
//            .sort({ timestamp: 1 });  // 按时间戳排序，从最早的记录开始

//         await Chat.updateMany(
//             {
//                 senderId: receiverId,   // 确保接受者为senderId
//                 receiverId: senderId,   // 确保发送者为receiverId
//                 isRead: { $ne: true }   // 仅更新未读的记录
//             },
//             {
//                 $set: { isRead: true }  // 将isRead字段设为true
//             }
//         );

//         // 返回查询到的聊天记录
//         res.status(200).json({
//             code: 200,
//             message: '获取信息成功',
//             data: chatRecords,
//             ok: true
//         });



//     } catch (error) {
//         console.error(error);
//         res.status(500).json({ message: "Server error" });
//     }
// });
router.post('/chatRecords', checkTokenMiddleware, async (req, res) => {
    try {
        // 获取请求体数据
        // const { senderId, receiverId, keyword, roomName } = req.body;
        // 修改为下面代码
         const { userId, keyword, roomName } = req.body;
        console.log(req.body);

        if (!userId|| !roomName) {
            return res.status(400).json({ message: "userID roomId are required" });
        }

        // 构建查询条件，加入 roomId
        let query = {
            roomName: roomName,
            // $or: [
            //     { senderId, receiverId },
            //     { senderId: receiverId, receiverId: senderId }
            // ]
        };

        // 如果提供了关键词，则添加正则搜索
        if (keyword) {
            query.content = { $regex: keyword, $options: 'i' };
        }



        // 批量更新未读消息为已读，加入 roomId 过滤条件
    //  修改为如果userId是receiverId则已读
        await Chat.bulkWrite([
            {
                updateMany: {
                    filter: {
                        roomName: roomName,
                        receiverId: userId,  // 确保更新当前用户接收的消息
                        isRead: { $ne: true }  // 只更新未读消息
                    },
                    update: { $set: { isRead: true } }
                }
            }
        ]);
        // 查询聊天记录
        const chatRecords = await Chat.find(query)
            .sort({ timestamp: 1 })
            .lean();  // 使用 lean() 返回普通 JS 对象，提高性能
        console.log('聊天记录', chatRecords);

        // 返回响应
        res.status(200).json({
            code: 200,
            message: '获取信息成功',
            data: chatRecords,
            ok: true
        });

    } catch (error) {
        console.error(error);
        res.status(500).json({ message: "Server error" });
    }
});
// 获取与各个好友的最后一条聊天记录
//获取各个聊天房间中最后的一条聊天记录
// router.post('/chatLast', checkTokenMiddleware, async (req, res) => {
//     try {
//         const userId = String(req.body.userId); // 从请求体中获取当前用户的ID,roomName[]

//         // 聚合管道：查找每个好友的最后一条消息，并返回好友信息和关系
//         const chats = await Chat.aggregate([
//             {
//                 $match: {
//                     $or: [
//                         { senderId: new mongoose.Types.ObjectId(userId) },
//                         { receiverId: new mongoose.Types.ObjectId(userId) }
//                     ]
//                 }
//             },
//             {
//                 $sort: { timestamp: -1 } // 按时间降序排序，确保最新的消息排在前面
//             },
//             {
//                 $group: {
//                     _id: {
//                         senderId: {
//                             $cond: [
//                                 { $eq: ["$senderId", new mongoose.Types.ObjectId(userId)] },
//                                 "$receiverId",
//                                 "$senderId"
//                             ]
//                         },
//                         receiverId: {
//                             $cond: [
//                                 { $eq: ["$receiverId", new mongoose.Types.ObjectId(userId)] },
//                                 "$receiverId",
//                                 "$senderId",
//                             ]
//                         }
//                     },
//                     lastMessage: { $first: "$content" },
//                     timestamp: { $first: "$timestamp" },
//                     isRead: { $first: "$isRead" }
//                 }
//             },
//             {
//                 $lookup: {
//                     from: "users",
//                     localField: "_id.senderId",
//                     foreignField: "_id",
//                     as: "sender"
//                 }
//             },
//             {
//                 $lookup: {
//                     from: "users",
//                     localField: "_id.receiverId",
//                     foreignField: "_id",
//                     as: "receiver"
//                 }
//             },
//             {
//                 $lookup: {
//                     from: "friendships", // 使用好友关系模型
//                     localField: "_id.senderId", // 通过发送者ID查找好友关系
//                     foreignField: "userId", // 关联当前用户
//                     as: "senderFriendship"
//                 }
//             },
//             {
//                 $lookup: {
//                     from: "friendships", // 使用好友关系模型
//                     localField: "_id.receiverId", // 通过接收者ID查找好友关系
//                     foreignField: "userId", // 关联当前用户
//                     as: "receiverFriendship"
//                 }
//             },
//             {
//                 $lookup: {
//                     from: "chats",
//                     let: { senderId: "$_id.senderId", receiverId: "$_id.receiverId" },
//                     pipeline: [
//                         {
//                             $match: {
//                                 $expr: {
//                                     $and: [
//                                         { $eq: ["$senderId", "$$senderId"] },
//                                         { $eq: ["$receiverId", "$$receiverId"] },
//                                         { $eq: ["$isRead", false] }
//                                     ]
//                                 }
//                             }
//                         },
//                         { $count: "unreadCount" }
//                     ],
//                     as: "unreadMessages"
//                 }
//             },
//             {
//                 $project: {
//                     "senderId": { $arrayElemAt: ["$sender._id", 0] },
//                     "receiverId": { $arrayElemAt: ["$receiver._id", 0] },
//                     "lastMessage": 1,
//                     "timestamp": 1,
//                     "isRead": 1,
//                     "senderName": { $arrayElemAt: ["$sender.username", 0] },
//                     "receiverName": { $arrayElemAt: ["$receiver.username", 0] },
//                     "senderAvatar": { $arrayElemAt: ["$sender.avatar", 0] },
//                     "receiverAvatar": { $arrayElemAt: ["$receiver.avatar", 0] },
//                     "unreadCount": { $ifNull: [{ $arrayElemAt: ["$unreadMessages.unreadCount", 0] }, 0] },
//                     "senderFriendshipId": { $arrayElemAt: ["$senderFriendship._id", 0] }, // 好友关系的 ID
//                     "receiverFriendshipId": { $arrayElemAt: ["$receiverFriendship._id", 0] } // 好友关系的 ID
//                 }
//             },
//             {
//                 // 在最终结果中，按照时间戳进行排序，确保结果按聊天的时间排序
//                 $sort: { timestamp: -1 }
//             }
//         ]);
//         console.log(chats);

//         // 返回给客户端
//         res.status(200).json({
//             code: 200,
//             message: '获取信息成功',
//             data: chats,
//             ok: true
//         });
//     } catch (err) {
//         console.error(err);
//         res.status(500).json({ success: false, message: 'Error retrieving chats' });
//     }
// });
router.post('/chatLast', checkTokenMiddleware, async (req, res) => {
    try {
        const userId = String(req.body.userId); // 从请求体中获取当前用户的ID
        let roomNames = req.body.roomNames; // 获取房间ID，可以是单个字符串或者数组
        console.log(roomNames);
        
        // 将 roomNames 中的每个元素转换为 ObjectId
        // 判断 roomNames 是否是字符串，如果是字符串则将其转换成数组
        if (typeof roomNames === 'string') {
            roomNames = [roomNames]; // 将单个字符串转为数组
        }
        const roomObjectIds = roomNames.map(room => new mongoose.Types.ObjectId(room));
        // console.log('房间', roomNames);



        // 聚合管道：查找每个房间的最后一条消息
        const chats = await Chat.aggregate([
            {
                $match: {
                    // 数据库的roomName是 mongoose.Schema.Types.ObjectId，roomNames的元素是string，怎么进行比较
                    roomName: { $in: roomObjectIds }, // 仅匹配指定房间的聊天记录
                }
            },
            {
                $sort: { timestamp: -1 } // 按时间降序排序，确保最新的消息排在前面
            },
            {
                $group: {
                    _id: "$roomName", // 按房间ID分组
                    lastMessage: { $first: "$content" },
                    timestamp: { $first: "$timestamp" },
                    isRead: { $first: "$isRead" },
                    senderId: { $first: "$senderId" }, // 获取发送者ID
                    receiverId: { $first: "$receiverId" } // 获取接收者ID
                }
            },
            {
                // 查找发送者和接收者信息
                $lookup: {
                    from: "users",
                    localField: "senderId",
                    foreignField: "_id",
                    as: "sender"
                }
            },
            {
                $lookup: {
                    from: "users",
                    localField: "receiverId",
                    foreignField: "_id",
                    as: "receiver"
                }
            },
            {
                // 计算未读消息数,返回的是以userId为receiverId的信息未读数量
                $lookup: {
                    from: "chats",
                    let: { roomName: "$_id",  receiverId: new mongoose.Types.ObjectId(userId) },
                    pipeline: [
                        {
                            $match: {
                                $expr: {
                                    $and: [
                                        { $eq: ["$roomName", "$$roomName"] },
                                        { $eq: ["$receiverId", "$$receiverId"] }, // 只计算当前用户作为接收者的消息
                                        { $eq: ["$isRead", false] }
                                    ]
                                }
                            }
                        },
                        { $count: "unreadCount" }
                    ],
                    as: "unreadMessages"
                }
            },
            {
                $project: {
                    roomName: 1,
                    lastMessage: 1,
                    timestamp: 1,
                    senderId: 1, // 返回 senderId
                    receiverId: 1, // 返回 receiverId
                    senderName: { $arrayElemAt: ["$sender.username", 0] },
                    receiverName: { $arrayElemAt: ["$receiver.username", 0] },
                    senderAvatar: { $arrayElemAt: ["$sender.avatar", 0] },
                    receiverAvatar: { $arrayElemAt: ["$receiver.avatar", 0] },
                    unreadCount: { $ifNull: [{ $arrayElemAt: ["$unreadMessages.unreadCount", 0] }, 0] }
                }
            }
        ]);

        console.log('最后', userId, chats);

        // 返回给客户端
        res.status(200).json({
            code: 200,
            message: '获取信息成功',
            data: chats,
            ok: true
        });
    } catch (err) {
        console.error(err);
        res.status(500).json({ success: false, message: 'Error retrieving chats' });
    }
});


// 删除与好友的全部聊天记录,
// 删除该房间的全部聊天记录
router.post('/deleteRecords', checkTokenMiddleware, async (req, res) => {
    try {
        // 获取请求体中的senderId和receiverId
        const { senderId, receiverId } = req.body;
        //  查询发送者为receiverId，接收者为senderId的记录||查询发送者为senderId，接收者为receiverId的记录,将这些记录全部删除
        if (!senderId || !receiverId) {
            return res.status(400).json({ message: "senderId and receiverId are required" });
        }

        // 构建查询条件
        let query = {
            $or: [
                { senderId, receiverId },  // 查询发送者为senderId，接收者为receiverId的记录
                { senderId: receiverId, receiverId: senderId }  // 查询发送者为receiverId，接收者为senderId的记录
            ]
        };

        const result = await Chat.deleteMany(query);//删除聊天记录

        // 返回删除结果
        if (result.deletedCount > 0) {
            return res.status(200).json({ message: "删除成功" });
        } else {
            return res.status(404).json({ message: "没有找到要删除的聊天记录" });
        }

    } catch (error) {
        console.error(error);
        res.status(500).json({ message: "Server error" });
    }
})
// 计算未读消息
// 
module.exports = router